home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 284_01 / machine.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-03-11  |  19.6 KB  |  552 lines
  1. /* machine.c - an 8080 machine instruction interpreter            */
  2.  
  3. #include <setjmp.h>
  4. #include "compile.h"
  5. #include "config.h"
  6. #include "defs.h"
  7.  
  8. BYTE Mem [ MEMSIZE ];            /* main memory for our 8080 CPU */
  9.  
  10. /* macros for 8080 registers                        */
  11.  
  12. #define B        RegB(regs)
  13. #define C        RegC(regs)
  14. #define D        RegD(regs)
  15. #define E        RegE(regs)
  16. #define H        RegH(regs)
  17. #define L        RegL(regs)
  18. #define A        RegA(regs)
  19. #define M        ( Mem[HL] )
  20.  
  21. #define BC        RegBC(regs)
  22. #define DE        RegDE(regs)
  23. #define HL        RegHL(regs)
  24.  
  25. #define X        RegX(regs)    /* X acts as a carry flag    */
  26. #define XA        RegXA(regs)
  27.  
  28. /* macros for flags                            */
  29.  
  30. #define CF        ( X & 1 )
  31. #define ZF        ( res == 0 )
  32. #define SF        ( res & 0x80 )
  33.  
  34. #if PFLAG
  35. #define PF        ( parity[res] )
  36. #else
  37. #define PF        XXXXXX()
  38. #endif
  39.  
  40. #if HFLAG
  41. #define HF        ( hf & 0x10 )
  42. #else
  43. #define HF        XXXXXX()
  44. #endif
  45.  
  46. #define CFF        CF
  47. #define ZFF        ( ZF << 6 )
  48. #define SFF        SF
  49.  
  50. #if PFLAG
  51. #define PFF        PF
  52. #else
  53. #define PFF        (0)
  54. #endif
  55.  
  56. #if HFLAG
  57. #define HFF        HF
  58. #else
  59. #define HFF        (0)
  60. #endif
  61.  
  62. /* macros to write operations of each instruction            */
  63.  
  64. #define GetB()        ( *ppc++ )
  65. #define GetW()        ( Lo(tp) = GetB(), Hi(tp) = GetB(), tp )
  66. #define IgnB()        ( ppc++ )
  67. #define IgnW()        ( ppc+=2 )
  68. #define NxB        ( *ppc )
  69. #define NxW        ( *ppc | ( *( ppc + 1 ) << 8 ) )
  70. #define Ma(a)        ( Mem+(a) )
  71. #define W(x)        ( (x)-Mem )
  72.  
  73. #define MkFF(r)        ( res = (r) )
  74. #define SetPSW(psw)    ( A=Hi(psw), res=setff( X=Hff(Lo(psw)) ) )
  75. #define ResPSW(psw)    ( Hi(psw)=A, Lo(psw)= SFF|ZFF|HFF|PFF|CFF )
  76. #define N(r)        ( (r)&0x0F )
  77.  
  78. /* macros related with an H flag                    */
  79.  
  80. #if HFLAG
  81. #define HfA(x,y,c)    ( hf=N(x)+N(y)+(c) )
  82. #define HfS(x,y,b)    ( hf=N(x)-N(y)-(b) )
  83. #define Hf0()        ( hf=0 )
  84. #define Hf1()        ( hf=0x40 )
  85. #define Hff(x)        ( hf=(x) )
  86. #define DAA()        ( XA = daa( XA, hf ) )
  87. #else
  88. #define HfA(x,y,c)
  89. #define HfS(x,y,b)
  90. #define Hf0()
  91. #define Hf1()
  92. #define Hff(x)        (x)
  93. #define DAA()        XXXXXX()
  94. #endif
  95.  
  96. /* macros for some specific instructions                */
  97.  
  98. #define DAD(x)        ( HL=ex=(EXTRA)HL+(x), X=ex>>16 )
  99.  
  100. #define Push(x)        ( *--psp=Hi(x), *--psp=Lo(x) )
  101. #define Pull(x)        ( Lo(x)=(*psp++), Hi(x)=(*psp++) )
  102. #define Jump(a)        ( ppc=Ma(a) )
  103. #define Call(a)        ( pp=Ma(a), tp=W(ppc), Push(tp), ppc=pp )
  104. #define Return()    ( Pull(tp), ppc=Ma(tp) )
  105.  
  106. #define BrCC(f,op)    if (f) op( GetW() ); else IgnW()
  107. #define RtCC(f)        if (f) Return()
  108.  
  109. #define nop()                    /* nothing to do    */
  110. #define halt()        longjmp( retpos, 1 )    /* stop executing    */
  111. #define XXXXXX()    ( XXX(--ppc), halt() )    /* illegal OP code    */
  112.  
  113. #if ! INOUT
  114. #define i_in(x,y)    XXXXXX()
  115. #define i_out(x,y)    XXXXXX()
  116. #endif
  117.  
  118. /* macro to execute external procedure                    */
  119. #define SUBMIT(func)    if (func) halt()
  120.  
  121. /* a table to caliculate parity flag                    */
  122.  
  123. #if PFLAG
  124. static BYTE parity [ 256 ] = {
  125.     4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
  126.     0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
  127.     0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
  128.     4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
  129.     0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
  130.     4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
  131.     4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
  132.     0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
  133.     0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
  134.     4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
  135.     4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
  136.     0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
  137.     4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
  138.     0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
  139.     0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
  140.     4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4
  141. };
  142. #endif
  143.  
  144. /* a special function/macro for POP PSW instruction            */
  145.  
  146. #if CKPSW
  147.  
  148. setff ( ff )
  149.     register int ff;
  150. {
  151.     if ( ff & 0x40 ) {
  152.     /* when Zero flag is on, Sign should be off, and Parity on */
  153. #if PFLAG
  154.     if ( ( ff & 0x84 ) != 0x04 ) {
  155.         i_flag();        /* alart it and ignore the case */
  156.     }
  157. #else
  158.     if ( ( ff & 0x80 ) != 0x00 ) {
  159.         i_flag();        /* alart it and ignore the case */
  160.     }
  161. #endif
  162.     return( 0x00 );
  163.     } else {
  164.     /* when Zero flag is off, other two can take any value */
  165.     if ( ff & 0x80 ) {
  166.         return( ( ff & 0x04 ) | 0x80 );
  167.     } else {
  168.         return( ( ff & 0x04 ) | 0x20 );
  169.     }
  170.     }
  171. }
  172.  
  173. #else /* CKPSW */
  174.  
  175. #define setff(x)    ( fftab[x] )
  176.  
  177. #define szp        0x04
  178. #define szP        0x24
  179. #define sZp        0x00    /* inconsistent */
  180. #define sZP        0x00
  181. #define Szp        0x80
  182. #define SzP        0x84
  183. #define SZp        0x00    /* inconsistent */
  184. #define SZP        0x00    /* inconsistent */
  185.  
  186. static BYTE fftab [ 256 ] = {
  187.  
  188.     szp,szp,szp,szp, szP,szP,szP,szP, szp,szp,szp,szp, szP,szP,szP,szP,
  189.     szp,szp,szp,szp, szP,szP,szP,szP, szp,szp,szp,szp, szP,szP,szP,szP,
  190.     szp,szp,szp,szp, szP,szP,szP,szP, szp,szp,szp,szp, szP,szP,szP,szP,
  191.     szp,szp,szp,szp, szP,szP,szP,szP, szp,szp,szp,szp, szP,szP,szP,szP,
  192.  
  193.     sZp,sZp,sZp,sZp, sZP,sZP,sZP,sZP, sZp,sZp,sZp,sZp, sZP,sZP,sZP,sZP,
  194.     sZp,sZp,sZp,sZp, sZP,sZP,sZP,sZP, sZp,sZp,sZp,sZp, sZP,sZP,sZP,sZP,
  195.     sZp,sZp,sZp,sZp, sZP,sZP,sZP,sZP, sZp,sZp,sZp,sZp, sZP,sZP,sZP,sZP,
  196.     sZp,sZp,sZp,sZp, sZP,sZP,sZP,sZP, sZp,sZp,sZp,sZp, sZP,sZP,sZP,sZP,
  197.  
  198.     Szp,Szp,Szp,Szp, SzP,SzP,SzP,SzP, Szp,Szp,Szp,Szp, SzP,SzP,SzP,SzP,
  199.     Szp,Szp,Szp,Szp, SzP,SzP,SzP,SzP, Szp,Szp,Szp,Szp, SzP,SzP,SzP,SzP,
  200.     Szp,Szp,Szp,Szp, SzP,SzP,SzP,SzP, Szp,Szp,Szp,Szp, SzP,SzP,SzP,SzP,
  201.     Szp,Szp,Szp,Szp, SzP,SzP,SzP,SzP, Szp,Szp,Szp,Szp, SzP,SzP,SzP,SzP,
  202.  
  203.     SZp,SZp,SZp,SZp, SZP,SZP,SZP,SZP, SZp,SZp,SZp,SZp, SZP,SZP,SZP,SZP,
  204.     SZp,SZp,SZp,SZp, SZP,SZP,SZP,SZP, SZp,SZp,SZp,SZp, SZP,SZP,SZP,SZP,
  205.     SZp,SZp,SZp,SZp, SZP,SZP,SZP,SZP, SZp,SZp,SZp,SZp, SZP,SZP,SZP,SZP,
  206.     SZp,SZp,SZp,SZp, SZP,SZP,SZP,SZP, SZp,SZp,SZp,SZp, SZP,SZP,SZP,SZP,
  207.  
  208. };
  209.  
  210. #endif /* CKPSW */
  211.  
  212. /* a special function for DAA instruction                */
  213.  
  214. #if HFLAG
  215.  
  216. daa( acc, hf )
  217.     WORD acc;
  218.     BYTE hf;
  219. {
  220.     if ( hf & 0x10 ) {
  221.     if ( ( Hi( acc ) & 1 ) || ( Lo( acc ) & 0xF0 ) > 0x90 ) {
  222.         return( acc + 0x66 );
  223.     } else {
  224.         return( acc + 0x06 );
  225.     }
  226.     } else if ( ( Lo( acc ) & 0x0F ) > 0x09 ) {
  227.     if ( ( Hi( acc ) & 1 ) || ( Lo( acc ) & 0xF0 ) > 0x80 ) {
  228.         return( acc + 0x66 );
  229.     } else {
  230.         return( acc + 0x06 );
  231.     }
  232.     } else {
  233.     if ( ( Hi( acc ) & 1 ) || ( Lo( acc ) & 0xF0 ) > 0x90 ) {
  234.         return( acc + 0x60 );
  235.     } else {
  236.         return( acc );
  237.     }
  238.     }
  239. }
  240.  
  241. #endif /* HFLAG */
  242.  
  243. /* main body of the machine - an 8080 machine instruction interpreter    */
  244.  
  245. void machine ()
  246. {
  247.     register BYTE * ppc;        /* used like program counter    */
  248.     register BYTE * psp;        /* used like stack pointer    */
  249.     REGS regs;                /* 8080 registers        */
  250.     BYTE res;                /* result of arith./logical op. */
  251. #if HFLAG
  252.     BYTE hf;                /* Half carry Flag        */
  253. #endif
  254.  
  255.     WORD tp;
  256.     WORD rp;
  257.     BYTE tb;
  258.     BYTE * pp;
  259.     EXTRA ex;
  260.     jmp_buf retpos;
  261.  
  262.     if ( setjmp( retpos ) ) return;
  263.  
  264.     ppc = Ma( 0 );            /* 8080 starts on address 0    */
  265.     psp = Ma( 0 );
  266.  
  267.     for (;;) {
  268. #if TRACE
  269.     if ( tflag ) trace( ppc, psp, ®s );
  270. #endif
  271.     switch ( GetB() ) {
  272. /*                                    */
  273. /*    OP code          Mnemonic       Operation                */
  274. /* -------------------------------------------------------------------- */
  275. /*                                    */
  276.     default:   /* ???    */ XXXXXX();                break;
  277.  
  278.     case 0x00: /* NOP    */ nop();                break;
  279.     case 0x01: /* LXI  B,nn */ C=GetB(), B=GetB();            break;
  280.     case 0x02: /* STAX B    */ Mem[BC]=A;                break;
  281.     case 0x03: /* INX  B    */ BC++;                break;
  282.     case 0x04: /* INR  B    */ HfA(B,1,0); MkFF(++B);        break;
  283.     case 0x05: /* DCR  B    */ HfS(B,1,0); MkFF(--B);        break;
  284.     case 0x06: /* MVI  B,n    */ B=GetB();                break;
  285.     case 0x07: /* RLC    */ X=A, XA<<=1, A=X; Hf0();        break;
  286. /*    case 0x08:        */
  287.     case 0x09: /* DAD  B    */ DAD(BC);                break;
  288.     case 0x0A: /* LDAX B    */ A=Mem[BC];                break;
  289.     case 0x0B: /* DEX  B    */ BC--;                break;
  290.     case 0x0C: /* INR  C    */ HfA(C,1,0); MkFF(++C);        break;
  291.     case 0x0D: /* DER  C    */ HfS(C,1,0); MkFF(--C);        break;
  292.     case 0x0E: /* MVI  C,n    */ C=GetB();                break;
  293.     case 0x0F: /* RRC    */ X=A, A=XA>>1; Hf0();            break;
  294.  
  295. /*    case 0x10:        */
  296.     case 0x11: /* LXI  D,nn */ E=GetB(), D=GetB();            break;
  297.     case 0x12: /* STAX D,nn */ Mem[DE]=A;                break;
  298.     case 0x13: /* INX  D    */ DE++;                break;
  299.     case 0x14: /* INR  D    */ HfA(D,1,0); MkFF(++D);        break;
  300.     case 0x15: /* DCR  D    */ HfS(D,1,0); MkFF(--D);        break;
  301.     case 0x16: /* MVI  D,n    */ D=GetB();                break;
  302.     case 0x17: /* RAL    */ tb=CF, XA<<=1, A|=tb; Hf0();        break;
  303. /*    case 0x18:        */
  304.     case 0x19: /* DAD  D    */ DAD(DE);                break;
  305.     case 0x1A: /* LDAX D    */ A=Mem[DE];                break;
  306.     case 0x1B: /* DEX  D    */ DE--;                break;
  307.     case 0x1C: /* INR  E    */ HfA(E,1,0); MkFF(++E);        break;
  308.     case 0x1D: /* DER  E    */ HfS(E,1,0); MkFF(--E);        break;
  309.     case 0x1E: /* MVI  E,n    */ E=GetB();                break;
  310.     case 0x1F: /* RRA    */ tb=A, A=XA>>1, X=tb; Hf0();        break;
  311.  
  312. /*    case 0x20:        */
  313.     case 0x21: /* LXI  H,nn */ L=GetB(), H=GetB();            break;
  314.     case 0x22: /* SHLD nn    */ pp=Ma(GetW()), *pp=L, *(pp+1)=H;    break;
  315.     case 0x23: /* INX  HL    */ HL++;                break;
  316.     case 0x24: /* INR  H    */ HfA(H,1,0); MkFF(++H);        break;
  317.     case 0x25: /* DER  H    */ HfS(H,1,0); MkFF(--H);        break;
  318.     case 0x26: /* MVI  H,n    */ H=GetB();                break;
  319.     case 0x27: /* DAA    */ DAA();                break;
  320. /*    case 0x28:        */
  321.     case 0x29: /* DAD  H    */ X=H>>7, HL<<=1;            break;
  322.     case 0x2A: /* LHLD nn    */ pp=Ma(GetW()), L=(*pp), H=(*(pp+1)); break;
  323.     case 0x2B: /* DEX  H    */ HL--;                break;
  324.     case 0x2C: /* INR  L    */ HfA(L,1,0); MkFF(++L);        break;
  325.     case 0x2D: /* DER  L    */ HfS(L,1,0); MkFF(--L);        break;
  326.     case 0x2E: /* MVI  L,n    */ L=GetB();                break;
  327.     case 0x2F: /* CMA    */ A^=0xFF; Hf1();            break;
  328.  
  329. /*    case 0x30:        */
  330.     case 0x31: /* LXI  SP,nn*/ psp=Ma(GetW());            break;
  331.     case 0x32: /* STA  nn    */ Mem[GetW()]=A;            break;
  332.     case 0x33: /* INX  SP    */ psp++;                break;
  333.     case 0x34: /* INR  M    */ HfA(M,1,0); MkFF(++M);        break;
  334.     case 0x35: /* DER  M    */ HfS(M,1,0); MkFF(--M);        break;
  335.     case 0x36: /* MVI  M,n    */ M=GetB();                break;
  336.     case 0x37: /* STC    */ X=1; Hf0();                break;
  337. /*    case 0x38:        */
  338.     case 0x39: /* DAD  SP    */ DAD(psp-Mem);            break;
  339.     case 0x3A: /* LDA  nn    */ A=Mem[GetW()];            break;
  340.     case 0x3B: /* DEX  SP    */ psp--;                break;
  341.     case 0x3C: /* INR  A    */ HfA(A,1,0); MkFF(++A);        break;
  342.     case 0x3D: /* DER  A    */ HfS(A,1,0); MkFF(--A);        break;
  343.     case 0x3E: /* MVI  A,n    */ A=GetB();                break;
  344.     case 0x3F: /* CMC    */ X^=1;                break;
  345.  
  346.     case 0x40: /* MOV  B,B    */ nop();                break;
  347.     case 0x41: /* MOV  B,C    */ B=C;                    break;
  348.     case 0x42: /* MOV  B,D    */ B=D;                    break;
  349.     case 0x43: /* MOV  B,E    */ B=E;                    break;
  350.     case 0x44: /* MOV  B,H    */ B=H;                    break;
  351.     case 0x45: /* MOV  B,L    */ B=L;                    break;
  352.     case 0x46: /* MOV  B,M    */ B=M;                    break;
  353.     case 0x47: /* MOV  B,A    */ B=A;                    break;
  354.     case 0x48: /* MOV  C,B    */ C=B;                    break;
  355.     case 0x49: /* MOV  C,C    */ nop();                break;
  356.     case 0x4A: /* MOV  C,D    */ C=D;                    break;
  357.     case 0x4B: /* MOV  C,E    */ C=E;                    break;
  358.     case 0x4C: /* MOV  C,H    */ C=H;                    break;
  359.     case 0x4D: /* MOV  C,L    */ C=L;                    break;
  360.     case 0x4E: /* MOV  C,M    */ C=M;                    break;
  361.     case 0x4F: /* MOV  C,A    */ C=A;                    break;
  362.  
  363.     case 0x50: /* MOV  D,B    */ D=B;                    break;
  364.     case 0x51: /* MOV  D,C    */ D=C;                    break;
  365.     case 0x52: /* MOV  D,D    */ nop();                break;
  366.     case 0x53: /* MOV  D,E    */ D=E;                    break;
  367.     case 0x54: /* MOV  D,H    */ D=H;                    break;
  368.     case 0x55: /* MOV  D,L    */ D=L;                    break;
  369.     case 0x56: /* MOV  D,M    */ D=M;                    break;
  370.     case 0x57: /* MOV  D,A    */ D=A;                    break;
  371.     case 0x58: /* MOV  E,B    */ E=B;                    break;
  372.     case 0x59: /* MOV  E,C    */ E=C;                    break;
  373.     case 0x5A: /* MOV  E,D    */ E=D;                    break;
  374.     case 0x5B: /* MOV  E,E    */ nop();                break;
  375.     case 0x5C: /* MOV  E,H    */ E=H;                    break;
  376.     case 0x5D: /* MOV  E,L    */ E=L;                    break;
  377.     case 0x5E: /* MOV  E,M    */ E=M;                    break;
  378.     case 0x5F: /* MOV  E,A    */ E=A;                    break;
  379.  
  380.     case 0x60: /* MOV  H,B    */ H=B;                    break;
  381.     case 0x61: /* MOV  H,C    */ H=C;                    break;
  382.     case 0x62: /* MOV  H,D    */ H=D;                    break;
  383.     case 0x63: /* MOV  H,E    */ H=E;                    break;
  384.     case 0x64: /* MOV  H,H    */ nop();                break;
  385.     case 0x65: /* MOV  H,L    */ H=L;                    break;
  386.     case 0x66: /* MOV  H,M    */ H=M;                    break;
  387.     case 0x67: /* MOV  H,A    */ H=A;                    break;
  388.     case 0x68: /* MOV  L,B    */ L=B;                    break;
  389.     case 0x69: /* MOV  L,C    */ L=C;                    break;
  390.     case 0x6A: /* MOV  L,D    */ L=D;                    break;
  391.     case 0x6B: /* MOV  L,E    */ L=E;                    break;
  392.     case 0x6C: /* MOV  L,H    */ L=H;                    break;
  393.     case 0x6D: /* MOV  L,L    */ nop();                break;
  394.     case 0x6E: /* MOV  L,M    */ L=M;                    break;
  395.     case 0x6F: /* MOV  L,A    */ L=A;                    break;
  396.  
  397.     case 0x70: /* MOV  M,B    */ M=B;                    break;
  398.     case 0x71: /* MOV  M,C    */ M=C;                    break;
  399.     case 0x72: /* MOV  M,D    */ M=D;                    break;
  400.     case 0x73: /* MOV  M,E    */ M=E;                    break;
  401.     case 0x74: /* MOV  M,H    */ M=H;                    break;
  402.     case 0x75: /* MOV  M,L    */ M=L;                    break;
  403.     case 0x76: /* HLT    */ halt();                break;
  404.     case 0x77: /* MOV  M,A    */ M=A;                    break;
  405.     case 0x78: /* MOV  A,B    */ A=B;                    break;
  406.     case 0x79: /* MOV  A,C    */ A=C;                    break;
  407.     case 0x7A: /* MOV  A,D    */ A=D;                    break;
  408.     case 0x7B: /* MOV  A,E    */ A=E;                    break;
  409.     case 0x7C: /* MOV  A,H    */ A=H;                    break;
  410.     case 0x7D: /* MOV  A,L    */ A=L;                    break;
  411.     case 0x7E: /* MOV  A,M    */ A=M;                    break;
  412.     case 0x7F: /* MOV  A,A    */ nop();                break;
  413.  
  414.     case 0x80: /* ADD  B    */ HfA(A,B,0);    MkFF(XA=A+B);        break;
  415.     case 0x81: /* ADD  C    */ HfA(A,C,0);    MkFF(XA=A+C);        break;
  416.     case 0x82: /* ADD  D    */ HfA(A,D,0);    MkFF(XA=A+D);        break;
  417.     case 0x83: /* ADD  E    */ HfA(A,E,0);    MkFF(XA=A+E);        break;
  418.     case 0x84: /* ADD  H    */ HfA(A,H,0);    MkFF(XA=A+H);        break;
  419.     case 0x85: /* ADD  L    */ HfA(A,L,0);    MkFF(XA=A+L);        break;
  420.     case 0x86: /* ADD  M    */ HfA(A,M,0);    MkFF(XA=A+M);        break;
  421.     case 0x87: /* ADD  A    */ MkFF(Hff(XA<<=1));            break;
  422.     case 0x88: /* ADC  B    */ HfA(A,B,CF); MkFF(XA=A+B+CF);    break;
  423.     case 0x89: /* ADC  C    */ HfA(A,C,CF); MkFF(XA=A+C+CF);    break;
  424.     case 0x8A: /* ADC  D    */ HfA(A,D,CF); MkFF(XA=A+D+CF);    break;
  425.     case 0x8B: /* ADC  E    */ HfA(A,E,CF); MkFF(XA=A+E+CF);    break;
  426.     case 0x8C: /* ADC  H    */ HfA(A,H,CF); MkFF(XA=A+H+CF);    break;
  427.     case 0x8D: /* ADC  L    */ HfA(A,L,CF); MkFF(XA=A+L+CF);    break;
  428.     case 0x8E: /* ADC  M    */ HfA(A,M,CF); MkFF(XA=A+M+CF);    break;
  429.     case 0x8F: /* ADC  A    */ MkFF(Hff(XA=(A<<1)|CF));        break;
  430.  
  431.     case 0x90: /* SUB  B    */ HfS(A,B,0);    MkFF(XA=A-B);        break;
  432.     case 0x91: /* SUB  C    */ HfS(A,C,0);    MkFF(XA=A-C);        break;
  433.     case 0x92: /* SUB  D    */ HfS(A,D,0);    MkFF(XA=A-D);        break;
  434.     case 0x93: /* SUB  E    */ HfS(A,E,0);    MkFF(XA=A-E);        break;
  435.     case 0x94: /* SUB  H    */ HfS(A,H,0);    MkFF(XA=A-H);        break;
  436.     case 0x95: /* SUB  L    */ HfS(A,L,0);    MkFF(XA=A-L);        break;
  437.     case 0x96: /* SUB  M    */ HfS(A,M,0);    MkFF(XA=A-M);        break;
  438.     case 0x97: /* SUB  A    */ MkFF(Hff(XA=0));            break;
  439.     case 0x98: /* SBB  B    */ HfS(A,B,CF); MkFF(XA=A-B-CF);    break;
  440.     case 0x99: /* SBB  C    */ HfS(A,C,CF); MkFF(XA=A-C-CF);    break;
  441.     case 0x9A: /* SBB  D    */ HfS(A,D,CF); MkFF(XA=A-D-CF);    break;
  442.     case 0x9B: /* SBB  E    */ HfS(A,E,CF); MkFF(XA=A-E-CF);    break;
  443.     case 0x9C: /* SBB  H    */ HfS(A,H,CF); MkFF(XA=A-H-CF);    break;
  444.     case 0x9D: /* SBB  L    */ HfS(A,L,CF); MkFF(XA=A-L-CF);    break;
  445.     case 0x9E: /* SBB  M    */ HfS(A,M,CF); MkFF(XA=A-M-CF);    break;
  446.     case 0x9F: /* SBB  A    */ MkFF(Hff(XA=(-CF)));            break;
  447.  
  448.     case 0xA0: /* ANA  B    */ MkFF(A&=B), X=0; Hf1();        break;
  449.     case 0xA1: /* ANA  C    */ MkFF(A&=C), X=0; Hf1();        break;
  450.     case 0xA2: /* ANA  D    */ MkFF(A&=D), X=0; Hf1();        break;
  451.     case 0xA3: /* ANA  E    */ MkFF(A&=E), X=0; Hf1();        break;
  452.     case 0xA4: /* ANA  H    */ MkFF(A&=H), X=0; Hf1();        break;
  453.     case 0xA5: /* ANA  L    */ MkFF(A&=L), X=0; Hf1();        break;
  454.     case 0xA6: /* ANA  M    */ MkFF(A&=M), X=0; Hf1();        break;
  455.     case 0xA7: /* ANA  A    */ MkFF(A   ), X=0; Hf1();        break;
  456.     case 0xA8: /* XRA  B    */ MkFF(A^=B), X=0; Hf0();        break;
  457.     case 0xA9: /* XRA  C    */ MkFF(A^=C), X=0; Hf0();        break;
  458.     case 0xAA: /* XRA  D    */ MkFF(A^=D), X=0; Hf0();        break;
  459.     case 0xAB: /* XRA  E    */ MkFF(A^=E), X=0; Hf0();        break;
  460.     case 0xAC: /* XRA  H    */ MkFF(A^=H), X=0; Hf0();        break;
  461.     case 0xAD: /* XRA  L    */ MkFF(A^=L), X=0; Hf0();        break;
  462.     case 0xAE: /* XRA  M    */ MkFF(A^=M), X=0; Hf0();        break;
  463.     case 0xAF: /* XRA  A    */ MkFF(A=0 ), X=0; Hf0();        break;
  464.  
  465.     case 0xB0: /* ORA  B    */ MkFF(A|=B), X=0; Hf0();        break;
  466.     case 0xB1: /* ORA  C    */ MkFF(A|=C), X=0; Hf0();        break;
  467.     case 0xB2: /* ORA  D    */ MkFF(A|=D), X=0; Hf0();        break;
  468.     case 0xB3: /* ORA  E    */ MkFF(A|=E), X=0; Hf0();        break;
  469.     case 0xB4: /* ORA  H    */ MkFF(A|=H), X=0; Hf0();        break;
  470.     case 0xB5: /* ORA  L    */ MkFF(A|=L), X=0; Hf0();        break;
  471.     case 0xB6: /* ORA  M    */ MkFF(A|=M), X=0; Hf0();        break;
  472.     case 0xB7: /* ORA  A    */ MkFF(A   ), X=0; Hf0();        break;
  473.     case 0xB8: /* CMP  B    */ HfS(A,B,0); MkFF(tp=A-B); X=Hi(tp);    break;
  474.     case 0xB9: /* CMP  C    */ HfS(A,C,0); MkFF(tp=A-C); X=Hi(tp);    break;
  475.     case 0xBA: /* CMP  D    */ HfS(A,D,0); MkFF(tp=A-D); X=Hi(tp);    break;
  476.     case 0xBB: /* CMP  E    */ HfS(A,E,0); MkFF(tp=A-E); X=Hi(tp);    break;
  477.     case 0xBC: /* CMP  H    */ HfS(A,H,0); MkFF(tp=A-H); X=Hi(tp);    break;
  478.     case 0xBD: /* CMP  L    */ HfS(A,L,0); MkFF(tp=A-L); X=Hi(tp);    break;
  479.     case 0xBE: /* CMP  M    */ HfS(A,M,0); MkFF(tp=A-M); X=Hi(tp);    break;
  480.     case 0xBF: /* CMP  A    */ MkFF(Hff(X=0));            break;
  481.  
  482.     case 0xC0: /* RNZ    */ RtCC(!ZF);                break;
  483.     case 0xC1: /* POP  B    */ Pull(BC);                break;
  484.     case 0xC2: /* JNZ  nn    */ BrCC(!ZF,Jump);            break;
  485.     case 0xC3: /* JMP  nn    */ Jump(GetW());            break;
  486.     case 0xC4: /* CNZ  nn    */ BrCC(!ZF,Call);            break;
  487.     case 0xC5: /* PUSH B    */ Push(BC);                break;
  488.     case 0xC6: /* ADI  n    */ HfA(A,NxB,0);  MkFF(XA=A+GetB());    break;
  489.     case 0xC7: /* RST  0    */ Call(0x00);                break;
  490.     case 0xC8: /* RZ    */ RtCC(ZF);                break;
  491.     case 0xC9: /* RET    */ Return();                break;
  492.     case 0xCA: /* JZ   nn    */ BrCC(ZF,Jump);            break;
  493. /*    case 0xCB:        */
  494.     case 0xCC: /* CZ   nn    */ BrCC(ZF,Call);            break;
  495.     case 0xCD: /* CALL nn    */ Call(GetW());            break;
  496.     case 0xCE: /* ACI  n    */ HfA(A,NxB,CF); MkFF(XA=A+GetB()+CF); break;
  497.     case 0xCF: /* RST  1    */ Call(0x08);                break;
  498.  
  499.     case 0xD0: /* RNC    */ RtCC(!CF);                break;
  500.     case 0xD1: /* POP  D    */ Pull(DE);                break;
  501.     case 0xD2: /* JNC  nn    */ BrCC(!CF,Jump);            break;
  502.     case 0xD3: /* OUT  n    */ SUBMIT(i_out(ppc++,®s));        break;
  503.     case 0xD4: /* CNC  nn    */ BrCC(!CF,Call);            break;
  504.     case 0xD5: /* PUSH D    */ Push(DE);                break;
  505.     case 0xD6: /* SUI  n    */ HfS(A,NxB,0);  MkFF(XA=A-GetB());    break;
  506.     case 0xD7: /* RST  2    */ Call(0x10);                break;
  507.     case 0xD8: /* RC    */ RtCC(CF);                break;
  508. /*    case 0xD9:        */
  509.     case 0xDA: /* JC   nn    */ BrCC(CF,Jump);            break;
  510.     case 0xDB: /* IN   n    */ SUBMIT(i_in(ppc++,®s));        break;
  511.     case 0xDC: /* CC   nn    */ BrCC(CF,Call);            break;
  512. /*    case 0xDD:        */
  513.     case 0xDE: /* SBI  n    */ HfS(A,NxB,CF); MkFF(XA=A-GetB()-CF); break;
  514.     case 0xDF: /* RST  3    */ Call(0x18);                break;
  515.  
  516.     case 0xE0: /* RPO    */ RtCC(!PF);                break;
  517.     case 0xE1: /* POP  H    */ Pull(HL);                break;
  518.     case 0xE2: /* JPO  nn    */ BrCC(!PF,Jump);            break;
  519.     case 0xE3: /* XTHL    */ tp=HL, Pull(HL), Push(tp);        break;
  520.     case 0xE4: /* CPO  nn    */ BrCC(!PF,Call);            break;
  521.     case 0xE5: /* PUSH H    */ Push(HL);                break;
  522.     case 0xE6: /* ANI  n    */ MkFF(A&=GetB()), X=0; Hf1();        break;
  523.     case 0xE7: /* RST  4    */ Call(0x20);                break;
  524.     case 0xE8: /* RPE    */ RtCC(PF);                break;
  525.     case 0xE9: /* PCHL    */ Jump(HL);                break;
  526.     case 0xEA: /* JPE  nn    */ BrCC(PF,Jump);            break;
  527.     case 0xEB: /* XCHG    */ rp=HL, HL=DE, DE=rp;            break;
  528.     case 0xEC: /* CPE  nn    */ BrCC(PF,Call);            break;
  529.     case 0xED: /* ESC  ?, n */ IgnB(); SUBMIT(esc(ppc++,®s));    break;
  530.     case 0xEE: /* XRI  n    */ MkFF(A^=GetB()), X=0; Hf0();        break;
  531.     case 0xEF: /* RST  5    */ Call(0x28);                break;
  532.  
  533.     case 0xF0: /* RP    */ RtCC(!SF);                break;
  534.     case 0xF1: /* POP  PSW    */ Pull(tp), SetPSW(tp);        break;
  535.     case 0xF2: /* JP   nn    */ BrCC(!SF,Jump);            break;
  536.     case 0xF3: /* DI    */ nop();                break;
  537.     case 0xF4: /* CP   nn    */ BrCC(!SF,Call);            break;
  538.     case 0xF5: /* PUSH PSW    */ ResPSW(tp), Push(tp);        break;
  539.     case 0xF6: /* ORI  n    */ MkFF(A|=GetB()), X=0; Hf0();        break;
  540.     case 0xF7: /* RST  6    */ Call(0x30);                break;
  541.     case 0xF8: /* RM    */ RtCC(SF);                break;
  542.     case 0xF9: /* SPHL    */ psp=Ma(HL);                break;
  543.     case 0xFA: /* JM   nn    */ BrCC(SF,Jump);            break;
  544.     case 0xFB: /* EI    */ nop();                break;
  545.     case 0xFC: /* CM   nn    */ BrCC(SF,Call);            break;
  546. /*    case 0xFD:        */
  547.     case 0xFE: /* CPI  n    */ HfS(A,NxB,0); MkFF(tp=A-GetB()), X=Hi(tp); break;
  548.     case 0xFF: /* RST  7    */ Call(0x38);                break;
  549.     }
  550.     }
  551. }
  552.